home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DNet / DNetObject.cpp < prev    next >
Encoding:
Text File  |  1996-07-05  |  10.6 KB  |  532 lines  |  [TEXT/R*ch]
  1. // DNetObject.cpp
  2. // from DGopher.cp  by d.g. gilbert, Mar 1992 
  3. // version for DClap, Jan 94
  4.  
  5.  
  6. #include <ncbi.h>
  7. #include <dgg.h> 
  8.  
  9. #include "DTCP.h"
  10. #include "DURL.h"
  11. #include "DNetObject.h"
  12.  
  13. #include <DFile.h>
  14. #include <DList.h>
  15. #include <DIconLib.h>
  16. #include <DView.h>
  17. #include <DChildApp.h>
  18.  
  19.  
  20. enum  commonTCPports {
  21.     kUnknownPort = 0,
  22.     kUnsupportedPort = 0,
  23.     kFileport = 21,
  24.     kFTPport = 21,
  25.     kSMTPport = 25,
  26.     kTelnetport = 23,
  27.     kTN3270port = 23,
  28.     kWhoisport= 43,
  29.     kGopherport = 70,
  30.     kFingerport = 79,
  31.     kHTTPport = 80,
  32.     kPOPport    = 110,
  33.     kBOPport    = 7110,
  34.     kNNTPport = 119,
  35.     kWAISport    = 210
  36.     };
  37.  
  38.  
  39. enum NetTypes {
  40.  kTypeFile         = '0',      // text file  
  41.  kTypeFolder        = '1',      // menu/directory 
  42.  kTypeCSO          = '2',        // CSO phone book service 
  43.  kTypeError        = '3',      // error 
  44.  kTypeBinhex        = '4',        // binhex encoded Macintosh file 
  45.  kTypeUuencode     = '6',      // uuencoded file 
  46.  kTypeQuery        = '7',      // question service 
  47.  kTypeTelnet       = '8',      // telnet service 
  48.  kTypeBinary       = '9',      // binary 
  49.  kTypeSound        = 's',      // sound 
  50.  kTypeImage            = 'I',        // image, probably gif
  51.  kTypeMovie            = ',',        // movie
  52.  kTypeNote            = 'i',        // note, information for directory
  53.  kTypeEndOfData    = '.',      // end of information 
  54.  kTypeGif                = 'g',    // GIF picture
  55.  kTypeWhois       = 'w',    // WHOIS phone book service -- not official, just easy 
  56.  kTypeTn3270      = 'T',     // Telnet variant -- just call diff app ?
  57.  kTypeHtml      = 'h',    // WWW type, ????
  58.  kTypeMime        = 'M',  // Mime, no mac reader yet
  59.  kMailType            = 'm',        // mailto, dgg addition for gopherpup
  60.     // obsolete types 
  61.  kTypeBinhexpc    = '5',  // binhex encoded MSDos file 
  62.  kTypeEvent        = 'e',  // ?? 
  63.  kTypeCal                 = 'c',  // ?? 
  64.  kTypeRedundant = '+',  // a redundant server holding the same information as the previous server
  65.  kTypeNull             = '\0'    // end of data
  66. };
  67.  
  68.  
  69.  
  70.  
  71.         //private    variables
  72.  
  73. Local const char*    kLocalhost    = "localhost";
  74. Local const char*    gEmptyString    = "";
  75.  
  76. Local const    long     kReadToClose = DTCP::kTCPStopAtclose;
  77. Local const    long     kReadToDotCRLF = DTCP::kTCPStopAtdotcrlf;
  78.  
  79. Local const    long     kReadMaxbuf1 = 1 * 1024; 
  80. Local const    long     kMaxInt = 32000;
  81.  
  82. Local const char *gMonths[13] = 
  83.     {"Jan","Feb","Mar","Apr","May","Jun",  "Jul","Aug","Sep","Oct","Nov","Dec","???"};
  84.  
  85.  
  86.  
  87.  
  88.  
  89.  
  90.  
  91. // DNetOb ------------------------------
  92.  
  93.  
  94.  
  95. DNetOb::DNetOb() :
  96.     DTaskMaster( 0, NULL, NULL)
  97. {
  98.     Initialize();
  99. }
  100.  
  101. DNetOb::DNetOb( DNetOb* nob)  :
  102.     DTaskMaster( 0, NULL, NULL) 
  103. {
  104.     Initialize();
  105.     Copy( nob);
  106. }
  107.  
  108.  
  109. DNetOb::~DNetOb()  
  110. {
  111.     MemFree( fName);
  112.     MemFree( fPath);
  113.     MemFree( fHost);
  114.     MemFree( fURL);
  115.     MemFree( fInfo);
  116.     MemFree( fQueryGiven);
  117.     MemFree( fUser);
  118.     MemFree( fPass);
  119. }
  120.  
  121.  
  122. Boolean DNetOb::suicide() 
  123. { 
  124.     if (GetOwnerCount() <= 1) { 
  125.         delete this; 
  126.         return true; 
  127.         }
  128.     else 
  129.         return DObject::suicide();
  130. }
  131.  
  132. Boolean DNetOb::suicide(short ownercount)
  133. {
  134.     if (ownercount < 1) {
  135.         delete this; 
  136.         return true; 
  137.         }
  138.     else 
  139.         return DObject::suicide(ownercount);
  140. }
  141.  
  142. DObject* DNetOb::Clone()
  143. {
  144.     DNetOb* nob= new DNetOb();
  145.     nob->Copy( this);
  146.     return nob;
  147. }
  148.  
  149.  
  150.  
  151. void DNetOb::Initialize()
  152. {
  153.     fName= NULL;
  154.     fPath= NULL;
  155.     fHost= NULL;
  156.     fURL= NULL;
  157.     fUser= NULL;
  158.     fPass= NULL;
  159.     
  160.     fType    = kTypeError; // == ancestor doesn't know much...
  161.     fProtocol = kGopherprot;
  162.     fPort= StandardPort( fProtocol);
  163.     fIsLocal= false;
  164.     fInfo= NULL;
  165.     fInfoSize= 0;
  166.     
  167.     fQuery= NULL;
  168.     fQueryGiven= NULL;
  169.     fInfo    = (char*)Nlm_MemGet(1, true); 
  170.     fInfoSize= 0; // fInfoSize is size of data not including terminating NULL !@!@$#@# 
  171. }
  172.  
  173. void DNetOb::Copy( DNetOb* anob)  
  174. {
  175.     if (anob) {
  176.     fProtocol= anob->fProtocol;      
  177.     fType     = anob->fType;                  
  178.     fName        = (char*) StrDup( (CharPtr)anob->fName);
  179.     fPath        = (char*) StrDup( (CharPtr)anob->fPath);
  180.     fHost        = (char*) StrDup( (CharPtr)anob->fHost);
  181.     fUser        = (char*) StrDup( (CharPtr)anob->fUser);
  182.     fPass        = (char*) StrDup( (CharPtr)anob->fPass);
  183.     fPort        = anob->fPort;      
  184.     fURL        = (char*) StrDup( (CharPtr)anob->fURL);
  185.     fIsLocal= anob->fIsLocal;
  186.     MemFree( fInfo); 
  187.     fInfoSize= anob->fInfoSize;
  188.     fInfo= (char*)MemDup( anob->fInfo, fInfoSize+1);
  189.     fQuery = anob->fQuery;             
  190.     fQueryGiven = StrDup( anob->fQueryGiven);         
  191.     }
  192. }
  193.  
  194. void DNetOb::DeleteInfo()
  195. {
  196.     if (fInfo) fInfo= (char*) MemMore( fInfo, 1);
  197.     else fInfo= (char*) MemNew(1);
  198.     *fInfo= 0;
  199.     fInfoSize= 0;
  200. }
  201.  
  202.  
  203.  
  204.  
  205. void DNetOb::StoreName(char* aStr)
  206. {
  207.     MemFree( fName);
  208.     fName= StrDup( aStr);
  209. }
  210.  
  211. void DNetOb::StorePath(char* aStr)
  212. {
  213.     MemFree( fPath);
  214.     fPath= StrDup( aStr);
  215. }
  216.  
  217. void DNetOb::StoreUser(char* aStr)
  218. {
  219.     MemFree( fUser);
  220.     fUser= StrDup( aStr);
  221. }
  222.  
  223. void DNetOb::StorePass(char* aStr)
  224. {
  225.     MemFree( fPass);
  226.     fPass= StrDup( aStr);
  227. }
  228.  
  229.  
  230. void DNetOb::StoreHost(char* aStr)
  231. {
  232.     if (!aStr || !*aStr || StrICmp(aStr,gEmptyString) == 0) 
  233.         aStr= (char*)kLocalhost;
  234.     MemFree( fHost);
  235.     fHost= StrDup( aStr);
  236.     fIsLocal= ( fHost==NULL 
  237.                             || StrICmp(fHost,kLocalhost) == 0  
  238.                             || StrICmp(fHost,gEmptyString) == 0 );
  239. }
  240.  
  241. void DNetOb::StorePort(char* aStr)
  242. {
  243.     short port= 0;
  244.     if (aStr) port= (short)atol(aStr); 
  245.     if (port) fPort= port;
  246. }
  247.  
  248.  
  249. // static
  250. short DNetOb::StandardPort( short protocol)
  251. {
  252.     switch (protocol) {
  253.         case kGopherprot: return kGopherport;
  254.         case kHTTPprot    : return kHTTPport;
  255.         case kSMTPprot    :    return kSMTPport;
  256.         case kBOPprot        :    return kBOPport;
  257.         case kFileprot    : return kFileport;
  258.         case kFTPprot        : return kFTPport;
  259.         case kTelnetprot: return kTelnetport;
  260.         case kTN3270prot: return kTN3270port;
  261.         case kWhoisprot    : return kWhoisport;
  262.         case kFingerprot: return kFingerport;
  263.         case kPOPprot        : return kPOPport;
  264.         case kNNTPprot    : return kNNTPport;
  265.         case kWAISprot    : return kWAISport;
  266.  
  267.         case kUnsupportedProt: return kUnsupportedPort;
  268.         default:
  269.         case kUnknownProt: return kUnknownPort;
  270.         }
  271. }
  272.  
  273. void DNetOb::StoreProtocol( short protocol)
  274. {
  275.     fProtocol= protocol;
  276.     fPort= StandardPort( fProtocol);
  277.     switch (fProtocol) {    
  278.             
  279.         case  kGopherprot    :  
  280.         case  kHTTPprot        :  
  281.         case  kFTPprot        : 
  282.         case  kBOPprot        : 
  283.         case  kFileprot        : 
  284.             // need to flag if localhost !? -- for all prots ??
  285.             fIsLocal= (StrICmp(GetHost(),kLocalhost) == 0 
  286.                             || StrICmp(GetHost(),gEmptyString) == 0 );
  287.             break;
  288.             
  289.             // currently unsupported
  290.         case  kNNTPprot        : 
  291.         case  kWAISprot        :  
  292.         case  kTelnetprot    :  
  293.         case  kTN3270prot    : 
  294.         case  kUnknownProt:
  295.         case  kUnsupportedProt:
  296.             fType= kTypeError; // ??
  297.             break;
  298.         }
  299. }
  300.  
  301.  
  302. const char* DNetOb::GetProtocol()
  303. {
  304. #if 0
  305.     short item= DNetOb::GetProtoItem(fProtocol);
  306.     if (item<0) return "unknown://";
  307.     return DNetOb::GetProtoName(item);
  308. #else
  309.     switch (fProtocol) {
  310.         case  kNNTPprot        : return "news:"; 
  311.         case  kSMTPprot        : return "mailto:"; 
  312.         case  kBOPprot        : return "bop://"; 
  313.         case  kGopherprot    : return "gopher://"; 
  314.         case  kHTTPprot        : return "http://"; 
  315.         case  kFTPprot        : return "ftp://";  // should be same as file:// ??
  316.         case  kFileprot        : return "file://"; 
  317.         case  kWAISprot        : return "wais://"; 
  318.         case  kTelnetprot    : return "telnet://"; 
  319.         case  kTN3270prot    : return "tn3270://"; 
  320.         
  321.         case  kUnknownProt: 
  322.         case  kUnsupportedProt: 
  323.         default: 
  324.                 return "unknown://";                
  325.         }
  326. #endif
  327. }
  328.  
  329. void DNetOb::StoreURL(char* aStr)
  330. {
  331.     MemFree(fURL); 
  332.     fURL= StrDup(aStr);
  333. }
  334.  
  335. const char* DNetOb::GetURL()
  336. {
  337. //    sprintf( buf, "URL: gopher://%s:%d/%c/%s%s", 
  338. //                    (char*) GetHost(), fPort, fType, (char*) GetPath(),LineEnd);
  339.     if (!fURL) {
  340.         char cstore[512];
  341.         char* url= StrDup( GetProtocol());
  342.         StrExtendCat( &url, (char*) GetHost());
  343.         if (fPort != StandardPort(fProtocol)) {
  344.             sprintf( cstore, ":%d", fPort);
  345.             StrExtendCat( &url, cstore);
  346.             }
  347.         
  348.         char* epath= DURL::EncodeChars( GetPath());
  349.         switch (fProtocol) {
  350.             case kGopherprot:
  351.                 sprintf( cstore, "/%c%s", fType,epath);
  352.                 StrExtendCat( &url, cstore);
  353.                 break;
  354.                 
  355.              case kFileprot:
  356.                 if (*epath != '/') {
  357.                     StrExtendCat( &url, "/");
  358.                     // ?? do some fiddling w/ *path ???
  359.                     }
  360.             default:
  361.                 StrExtendCat( &url, epath);
  362.                 break;
  363.             }
  364.             
  365.         MemFree( epath);
  366.         
  367.         if (fQueryGiven) {
  368.             StrExtendCat( &url, "?");
  369.             StrExtendCat( &url, fQueryGiven);
  370.             }
  371.             
  372.         fURL= url;
  373.         }
  374.     return fURL;
  375. }
  376.  
  377.  
  378.  
  379.  
  380.  
  381. Boolean DNetOb::Equals(DNetOb* other)
  382. {
  383.     if (!other) return false;
  384.     else if (fType != other->fType) return false;
  385.     else if (fPort != other->fPort) return false;
  386.     else if (fProtocol != other->fProtocol) return false;
  387.     else if (StringCmp( fHost, other->fHost)) return false;
  388.     else if (StringCmp( fPath, other->fPath)) return false;
  389.     else if (StringCmp( fQueryGiven, other->fQueryGiven)) return false;
  390.     else return true;
  391. }
  392.  
  393. Boolean DNetOb::operator ==(DNetOb* other)
  394. {
  395.     return Equals(other);
  396. }
  397.             
  398.  
  399.  
  400.  
  401. const char* DNetOb::GetKindName() 
  402. { 
  403.     return "Unknown"; 
  404. }
  405.  
  406. const char* DNetOb::GetName()   
  407. {
  408.     if (fName) return  fName;
  409.     else return gEmptyString;
  410. }
  411.  
  412. const char* DNetOb::GetPath()   
  413. {
  414.     if (fPath) return fPath;
  415.     else return gEmptyString;
  416. }
  417.  
  418. const char* DNetOb::GetHost()   
  419. {
  420.     if (fHost) return fHost;
  421.     else return gEmptyString;
  422. }
  423.  
  424. const char* DNetOb::GetUser()   
  425. {
  426.     if (fUser) return  fUser;
  427.     else return gEmptyString;
  428. }
  429.  
  430. const char* DNetOb::GetPass()   
  431. {
  432.     if (fPass) return  fPass;
  433.     else return gEmptyString;
  434. }
  435.  
  436. const char* DNetOb::GetPort()   
  437. {
  438.     static char sport[20];
  439.     if (fPort) {
  440.         sprintf(sport,"%d",fPort);
  441.         return sport;
  442.         }
  443.     else return gEmptyString;
  444. }
  445.  
  446.  
  447. const char* DNetOb::ShortName()   
  448. {
  449.     static char  shorty[33];
  450.     if (fName) {
  451.         strncpy(shorty, fName, 32);
  452.         shorty[33]= 0;
  453.         return shorty;
  454.         }
  455.     else return gEmptyString;
  456. }
  457.  
  458.  
  459.  
  460.  
  461.  
  462.  
  463.  
  464.  
  465.  
  466.  
  467.  
  468.  
  469.  
  470. struct nobTypeRec {
  471.     char kind;
  472.     const char* name;
  473.     Boolean supported:1;
  474.     };
  475.  
  476.  
  477. Local nobTypeRec gProtoTypes[] = {
  478.     { DNetOb::kGopherprot, "gopher://", true },
  479.     { DNetOb::kHTTPprot, "http://", true },
  480.     { DNetOb::kFileprot, "file://", true },
  481.     { DNetOb::kFTPprot, "ftp://", true },
  482.     { DNetOb::kSMTPprot,"mailto:", true },
  483.     { DNetOb::kBOPprot,"bop://", true },
  484.     { DNetOb::kWAISprot, "wais://", false },
  485.     { DNetOb::kTelnetprot, "telnet://", false },
  486.     { DNetOb::kTN3270prot, "tn3270://", false },
  487.     { DNetOb::kNNTPprot, "news:", false },
  488.     { DNetOb::kFingerprot, "finger:", true },
  489.     { DNetOb::kWhoisprot, "whois:", true },
  490.     { DNetOb::kUnsupportedProt, "unsupported://", true },
  491.     { DNetOb::kUnknownProt, "unknown://", true },
  492.     {0,0}
  493.     };
  494.  
  495. //static
  496. const char* DNetOb::GetProtoName( short listitem)
  497. {
  498.     if (listitem>=0 && listitem < (sizeof(gProtoTypes) / sizeof(nobTypeRec)))
  499.         return gProtoTypes[listitem].name;
  500.     else
  501.         return NULL;
  502. }
  503.  
  504. char DNetOb::GetProtoVal( short listitem)
  505. {
  506.     if (listitem>=0 && listitem < (sizeof(gProtoTypes) / sizeof(nobTypeRec)))
  507.         return gProtoTypes[listitem].kind;
  508.     else
  509.         return 0;
  510. }
  511.  
  512. Boolean DNetOb::GetProtoSupport( short listitem)
  513. {
  514.     if (listitem>=0 && listitem < (sizeof(gProtoTypes) / sizeof(nobTypeRec)))
  515.         return gProtoTypes[listitem].supported;
  516.     else
  517.         return 0;
  518. }
  519.  
  520. short DNetOb::GetProtoItem( char theProto)
  521. {
  522.     short i;
  523.     for (i=0; i < ( sizeof(gProtoTypes) / sizeof(nobTypeRec)); i++) {
  524.         if (gProtoTypes[i].kind == theProto) return i;
  525.       }
  526.     return -1;
  527. }
  528.  
  529.  
  530.  
  531.  
  532.